// 通用辅助工具函数

/**
 * 构建URL查询字符串
 * @param {Object} params - 查询参数对象
 * @returns {string} 查询字符串
 */
export const buildQueryString = (params) => {
    if (!params || Object.keys(params).length === 0) {
        return '';
    }

    const queryParams = Object.entries(params)
        .filter(([key, value]) => value !== undefined && value !== null && value !== '')
        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
        .join('&');

    return queryParams ? `?${queryParams}` : '';
};

/**
 * 生成唯一ID
 * @param {string} prefix - ID前缀
 * @returns {string} 唯一ID
 */
export const generateId = (prefix = 'id') => {
    return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
};

/**
 * 防抖函数
 * @param {Function} func - 要防抖的函数
 * @param {number} wait - 等待时间（毫秒）
 * @returns {Function} 防抖后的函数
 */
export const debounce = (func, wait) => {
    let timeout;
    return function executedFunction(...args) {
        const later = () => {
            clearTimeout(timeout);
            func(...args);
        };
        clearTimeout(timeout);
        timeout = setTimeout(later, wait);
    };
};

/**
 * 节流函数
 * @param {Function} func - 要节流的函数
 * @param {number} limit - 时间限制（毫秒）
 * @returns {Function} 节流后的函数
 */
export const throttle = (func, limit) => {
    let inThrottle;
    return function executedFunction(...args) {
        if (!inThrottle) {
            func.apply(this, args);
            inThrottle = true;
            setTimeout(() => inThrottle = false, limit);
        }
    };
};

/**
 * 深拷贝对象
 * @param {any} obj - 要拷贝的对象
 * @returns {any} 深拷贝后的对象
 */
export const deepClone = (obj) => {
    if (obj === null || typeof obj !== 'object') {
        return obj;
    }

    if (obj instanceof Date) {
        return new Date(obj.getTime());
    }

    if (obj instanceof Array) {
        return obj.map((item) => deepClone(item));
    }

    if (typeof obj === 'object') {
        const clonedObj = {};
        for (const key in obj) {
            if (obj.hasOwnProperty(key)) {
                clonedObj[key] = deepClone(obj[key]);
            }
        }
        return clonedObj;
    }
};

/**
 * 检查对象是否为空
 * @param {any} obj - 要检查的对象
 * @returns {boolean} 是否为空
 */
export const isEmpty = (obj) => {
    if (obj == null) return true;
    if (typeof obj === 'string' || Array.isArray(obj)) return obj.length === 0;
    if (typeof obj === 'object') return Object.keys(obj).length === 0;
    return false;
};

/**
 * 获取信号强度等级
 * @param {number} rssi - 信号强度值
 * @returns {string} 信号等级
 */
export const getSignalLevel = (rssi) => {
    if (rssi > -50) return 'excellent';
    if (rssi > -60) return 'good';
    if (rssi > -80) return 'fair';
    if (rssi > -100) return 'poor';
    return 'very_poor';
};

/**
 * 获取信号强度颜色
 * @param {number} rssi - 信号强度值
 * @returns {string} 对应的颜色值
 */
export const getSignalColor = (rssi) => {
    if (rssi > -60) return '#52c41a';
    if (rssi > -80) return '#faad14';
    return '#f5222d';
};

/**
 * 存储到本地存储
 * @param {string} key - 存储键
 * @param {any} value - 存储值
 */
export const setStorage = (key, value) => {
    try {
        localStorage.setItem(key, JSON.stringify(value));
    } catch (error) {
        console.error('存储数据失败:', error);
    }
};

/**
 * 从本地存储获取数据
 * @param {string} key - 存储键
 * @param {any} defaultValue - 默认值
 * @returns {any} 存储的值或默认值
 */
export const getStorage = (key, defaultValue = null) => {
    try {
        const item = localStorage.getItem(key);
        return item ? JSON.parse(item) : defaultValue;
    } catch (error) {
        console.error('读取存储数据失败:', error);
        return defaultValue;
    }
};

/**
 * 移除本地存储数据
 * @param {string} key - 存储键
 */
export const removeStorage = (key) => {
    try {
        localStorage.removeItem(key);
    } catch (error) {
        console.error('删除存储数据失败:', error);
    }
};
